Functions

Add

The rules are:

1. child bust be free
2. parent and child must be compatible

AppMessage

The rules are:

1. obj can be any kind of object not only a window
2. obj must be in a window linked to an application

AppPushId

You pass it the name of an Application object and it will return a key string ID that can be exported to another ARexx macros and used with PushMethod().

The result is NOT of your interest: the only thing you can do is to match it with Null() to see if the function failed (may fail iff its argument is not an application).

This is the mechanism used to control a RxMUI object outside the macro where it was created (remember that MUI in itself is monotask oriented and RxMUI is supposed to be SAFE):

• in macro A:
  • create your application
  • obtain a key with this function.
  • launch the other macro B and pass it the key
• in macro B
  • use PushMethod() with the key as first argument

  Any time PushMethod() is used in B , the macro B is suspended until the method reaches its goal. This makes the all thing very safe.

• in macro A:

      key = AppPushID("app")
      address command "run >nil: <nil: B" c2x(key)

• in macro B:

      parse arg id
      id = x2c(id)
      call PushMethod(id,"info","set","contents","Ok, I started")

DandD

At the moment, flags is one or more of:

• NOSELF - forbid an object (e.g. a List) to perform drag and drop within itself; the other flags are ignored, so d&d must be handled manually
• BOTH - the d&d is also from to to from
• REMOVE - remove dragged entries from a Listview
• AUTO - drag & drop is performed internally by RxMUI itself, between:
  • list <-> list
  • list <-> string
  • list -> text
  • string <-> string
  • string -> text

If you don't specify AUTO, drag and drop must be handled by yourself in the macro. Look at the examples.

Dispose

The rules are:

1. The object can refuse to be disposed
2. The object is first removed and then disposed
3. Any notification to the object is killed

DoMethod

Any class defines the rules for its own methods.

PushMethod

GetAttr

call GetAttr("string","contents","c")
say c

xget

Warning: if the attribute is a string, not numeric, its value will be truncated to the first null char found.

say xget("string","contents")

Handle

Handles the object app of class Application.

Handling of applications in RxMUI is done via this function.

The standard cycle to do that is:

    ctrl_c=2**12
    s=0
    do forever
        call handle("APP","H",s)
        do i=0 to h.num-1
            if h.i="QUIT" then exit
            if h.i==... then
            ...
        end
        s=Wait(or(h.signals,ctrl_c))
        if and(s,ctrl_c)~=0 then exit
    end

Handle() writes in stem.num the number of the entries to be parsed and in stem.i i=0,...,stem.num-1 the name of the object.

When stem.i is QUIT the application wants to exit and the user should exit from the macro or dispose the application.

Otherwise stem.i is the name of an object that notified the application via a

    res = Notify(obj,attr,value,"APP","RETURNID")

The cycle is very critical: if you do time consuming operation (ARexx is slow !!!) you should invoke the method INPUTBUFFERED on the application as in:

    ctrl_c=2**12
    s=0
    do forever
        call handle("APP","H",s)
        do i=0 to h.num-1
            if h.i="QUIT" then exit
            if h.i=="GO" then
                do i=0 to 1000
                    say i
                    call DoMethod("APP","INPUTBUFFERED")
                end
            end
        end
        s=Wait(or(h.signals,ctrl_c))
        if and(s,ctrl_c)~=0 then exit
    end

If you need to wait for other signals (e.g. for messages on a port) you can pass them to the rmh.library/Wait() function.

NewHandle

Handling of applications in RxMUI is done via this function.

The standard cycle to do that is:

    ctrl_c=2**12
    do forever
        call NewHandle("APP","H",ctrl_c)
        if and(h.signals,ctrl_c)>0 then exit
        select
            when h.event="QUIT" then exit
            when h.event==... then
            ...
        end
    end

As you can see the difference with Handle() is that NewHandle() always returns just one event and waits internally for the signals.

You should use Handle() only in the case you really have to wait for the signals in your code (e.g. you have to call rxsocket.library/WaitSelect() to wait for sockets events).

NewHandle() reads from stem:

• .NoWait - a boolean wich indicates if the function should wait for signals or not. Default is 1.

NewHandle() writes in stem:

• .EventFlag - a boolean which indicates that there is an event to be dispatched
• .Event - the name of the event that triggered a notification to the application.
• .Signals - the user-signals received, if any

When stem.event is QUIT the application wants to exit and the user should exit from the macro or dispose the application.

Otherwise stem.event is the name of an object that notified the application via a

    res = Notify(obj,attr,value,"APP","RETURNID")

If you need to wait for other signals (e.g. for messages on a port) you can pass them to the function.

• app - the Application object to handle
• stem - stem name the function will fill
• signals - user signals to wait for

Notify

Help

The same string can be obtained with rxhelp.

KillNotify

NewObj

freeChild makes NewObj() destroy all the internal buffers and resets child stems.

Note that during object creation, all the objects defined in objName itself or stem, if supplied, are created.

XNewObj

freeChild makes XNewObj() destroy all the internal buffers and resets child stems.

Remove

The rules are:

1. The object may refuse to be removed

Set

call set("win","open",1)

SetAttrs

set.disabled=0
set.contents="I am disabled"
call SetAttrs("string","set")

MultiGetAttr

get.0="host" ; get.0.attr="contents"
get.1="hostport" ; get.1.attr="integer"
call MultiGetAttr("get")
say get.0.value
say get.1.value

MultiSetAttr

set.0="host"; set.0.attr="contents";set.0.value="www.amiga.org"
set.1="hostport"; set.1.attr="integer"; set.1.value = 80
call MultiSetAttr("set")

Button

ToggleButton

Checkmark

HBar

VBar

HSpace

VSpace

HVSpace

MenuItem

title can be the special value "BAR" to create a bar.

Label

flags is one of:

• LEFT
• CENTER

MakeObj

Type can be one of:

• Balance - creates a Balance object.
  No parm defined.
• BarTitle - creates a Bar with a title.
  Parms are:
  [text]
• BetterBalance - creates a BetterBalance object.
  Parms are:
  <ObjectID/N>
• Busy - creates a Busy object.
  No parm defined.
• ColGroup - creates a columned Group.
  Parms are:
  <cols/N>,<obj1>,{obj}
• Cycle - creates a Cycle object.
  Parms are:
  <entries>,[key],[active/N]
• Gauge - creates a horiz Gauge object.
  Parms are:
  [FixHeightTxt],[max/N],[current/N],[InfoText]
• HBar - creates a horiz Bar.
  Parms are:
  [pixels/N]
• HCenter - center one object in a horiz Group.
  Parms are:
  <obj>
• HFrameGroup - incapsulate one object in a horiz framed Group.
  Parms are:
  [title],<obj>,[class]
• HGroup - creates a horiz Group.
  Parms are:
  <obj1>,{obj}
• HLeft - incapsulate one object in a horiz Group with an hspace at the right.
  Parms are:
  <obj>
• HRight - incapsulate one object in a horiz Group with an hspace at the left.
  Parms are:
  <obj>
• HSpace - creates a horiz Space.
  Parms are:
  [pixels/N]
• ImageButton - creates an Image button.
  Parms are:
  [imgSpec],[key],[selected/N]
• Knob - creates a Knob.
  Parms are:
  [key],[min/N],[max/N],[val/N],[default/N]
• Levelmeter - creates a Levelmeter.
  Parms are:
  [key],[min/N],[max/N],[val/N],[label],[default/N]
• Menu - creates a Menu.
  Parms are:
  <title>,{obj}
  
• Menuitem - adds Menuitems to a Menuitem.
  Parms are:
  <MainMenuitem>,{Menuitem}
• Menustrip - creates a Menu strip.
  Parms are:
  {obj}
  
• Numericbutton - creates a Numericbutton.
  Parms are:
  [key],[min/N],[max/N],[val/N],[format],[default/N]
• NumericString - creates a numeric String.
  Parms are:
  [key],[min/N],[max/N],[maxlen/N],[val/N]
• Radio - creates a Radio object.
  Parms are:
  <entries>[key],[active/N]
• RowGroup - creates a rowed group.
  Parms are:
  <rows/N>,<obj1>,{obj}
• Scale - creates a Scale object.
  No parm defined.
• Slider - creates a Slider.
  Parms are:
  [key],[min/N],[max/N],[val/N],[format],[default/N]
• VBar - creates a vert Bar.
  Parms are:
  [pixels/N]
• VCenter - center one object in a vert Group.
  Parms are:
  <obj>
• VDown - incapsulate one object in a vert Group with an hspace at the bottom.
  Parms are:
  <obj>
• VFrameGroup - incapsulate one object in a vert framed Group.
  Parms are:
  [title],<obj>,[class]
• VGroup - creates a vert Group.
  Parms are:
  <obj1>,{obj}
• VSpace - creates a vert Space.
  Parms are:
  [pixels/N]
• VUp - incapsulate one object in a vert Group with an hspace at the top.
  Parms are:
  <obj>

String

Text

ParseText

Refer to the MUI text class autodoc.

The changes made on text are:

• %c is changed to \\33c ("1B"x || c) (where c is ANY char)
• \n is changed to "0A"x
• \r is changed to "0D"x

Without this function the strings to pass as CONTENTS attribute of text line or as TEXT parameters of a Button object or as entry of a List object would be too complicated.

Child

    call child("G","S","STRING")

just tells RxMUI to:

• init g.0 to S - if it is the first time that child("G" ... ) is used
• init g.i to S - if it the i-th time that child("G" ...) is used s.class="STRING"

A often used form is as in

    call child("MPROJECT",Menuitem("MOPEN","Open","O"))

MUIRequest

This function is descouraged. Use it sparerly, just to show errors and then exit.

If you have to report messages to the user, you should better open a little window with a text (floattext) object and use it.

SetRxMUIStack

Every RxMUI function is executed under a stack swap.

Default stack size is 24k, but in certain situation with some object, e.g. with NListview, a very large stack is required. You can set the stack size with this function. RxMUI will allocate the new stack iff size is >16k bytes. If the stack can not be allocated error 3 is generated.

GetRxMUIString

At this moment RxMUI errors code are:

If an error is returned the var RxMUIErr is set to something meaningful, if possible.

RxMUIOpt

• DEBUGMODE
• SHOWERR

When many objects are created via one single NewObj() call, if an object anywhere can NOT be created, all the created objects are disposed (if possible) and NewObj() returns an error code.

You have no way to know where the creation process stopped and the error was generated. During debugging of a macro is very useful to know exactly which object had problem and or where the problem
appeared.

Setting DEBUGMODE makes RxMUI to remember the first error it discovered in NewObj().

Setting SHOWERR make RxMUI to show a MUI requester with info inside.

After you debugged your macro, you should remove the RxMUIOpt(), because it is supposed that if an error occurs in NewObj(), it is not your fault anymore, but something else such as a "too few memory" condition.

If you don't specify an option, it is cleared.

opt may also be ASK in which case the string
rxmui.library ver.rev (date) [user] Stack MinDefaultStack MinStack DefaultMinStack DebugMode ShowErr
is returned.

RxMUIObjExists

RxMUIObjList

RxMUIGetVar

RxMUISetVar